# pylint:disable=W1309,C0116,C0301,C0103,C0115,R0903,W0718,C0303,W0621,W0201,C0305,C0114,C0302,W0105,W1401,E0001,W0238
import asyncio
import datetime
import os
import platform
import re
import shutil
import xmlrpc.client


class ST:
    blog_url = ""
    blog_id = ""
    username = ""
    password = ""


class MarkdownToCnblog:
    """_summary_
    Returns:
        _type_: _description_
    """

    __slots__ = [
        "path",
        "base_dir",
        "raw_md",
        "images",
        "net_images",
        "raw_md",
        "new_md",
        "mime_mapping",
        "server",
        "blog_title",
        "blog_tags",
        "img_format",
        "gen_network_file",
        "publish",
    ]

    def __init__(self, path: str) -> None:
        self.path = path
        self.base_dir = os.path.dirname(path)
        self.net_images = []
        self.mime_mapping = {
            ".ico": "image/x-icon",
            ".jpg": "image/jpeg",
            ".jpe": "image/jpeg",
            ".jpeg": "image/jpeg",
            ".png": "image/png",
        }
        self.img_format = "typora"
        self.publish = True
        self.gen_network_file = False
        try:
            self.server = xmlrpc.client.ServerProxy(ST.blog_url)
        except Exception as ex:
            if "unsupported XML-RPC protocol" in str(ex):
                print("请查看config.yaml文件中的blog_url,应该是这个URL地址没设置对")

    def upload_markdown(self):
        self.__read_markdown()
        self.__find_md_img()
        self.__upload_img()
        self.__get_title_and_tag()
        self.__upload_blog()

    def __get_title_and_tag(self):
        res = re.findall(re.compile(r"<!--(.*)-->"), self.raw_md)
        if len(res) > 0:
            self.blog_title = res[0].strip()
            self.blog_tags = res[1].strip()

    def __upload_blog(self):
        post = dict(
            description=self.new_md,
            title=self.blog_title,
            categories=["[Markdown]"],
            mt_keywords=self.blog_tags,
        )
        try:
            self.server.metaWeblog.newPost(
                ST.blog_id, ST.username, ST.password, post, self.publish
            )
            print(f"===========上传成功===============")
        except Exception as ex:
            print(f"上传失败,相同博文已存在{ex}")

    def __upload_img(self):
        """upload img"""
        if self.images:  # 有本地图片，异步上传
            tasks = []
            for i, li in enumerate(self.images):
                if li.startswith("/"):  # 本地图片
                    li = "." + li
                image_full_path = os.path.join(self.base_dir, li)
                if not os.path.exists(image_full_path):
                    print(f"图片{image_full_path}不存在")
                    continue
                task = asyncio.ensure_future(self.__upload_md_img(image_full_path))
                task.add_done_callback(
                    lambda futrue, idx=i, img_path=image_full_path: self.get_image_url(
                        futrue, idx, img_path
                    )
                )
                tasks.append(task)
            if len(tasks) == 0:
                return
            loop = asyncio.get_event_loop()
            loop.run_until_complete(asyncio.wait(tasks))
            loop.close()
            image_mapping = dict(zip(self.images, self.net_images))
            self.new_md = self.replace_md_img(image_mapping)

    def get_image_url(self, t: asyncio.Task, idx, img_path):
        """回调，获取url"""
        img_url = t.result()
        print(f"{idx}->\t{img_path}\t上传成功,URL:{img_url}")
        self.net_images.append(img_url)

    async def __upload_md_img(self, path):
        """上传图片"""
        await asyncio.sleep(2)
        name = os.path.basename(path)
        _, suffix = os.path.splitext(name)
        with open(path, "rb") as f:
            file = {"bits": f.read(), "name": name, "type": self.mime_mapping[suffix]}
            url = self.server.metaWeblog.newMediaObject(
                ST.blog_id, ST.username, ST.password, file
            )
            return url.get("url")

    def __find_md_img(self):
        """查找markdown中的图片，排除网络图片(不用上传)"""
        images = re.findall("!\\[.*?\\]\\((.*)\\)", self.raw_md)
        images += re.findall('<img src="(.*?)"', self.raw_md)
        self.images = [i for i in images if not re.match("((http(s?))|(ftp))://.*", i)]
        print(f"共找到{len(images)}张本地图片{images}")

    def __read_markdown(self):
        with open(self.path, "r", encoding="utf-8") as f:
            self.raw_md = f.read()
            self.new_md = self.raw_md

    def replace_md_img(self, img_mapping):
        """替换markdown中的图片链接"""
        with open(self.path, "r", encoding="utf-8") as fr:
            md = fr.read()
            for local, net in img_mapping.items():  # 替换图片链接
                md = md.replace(local, net)
            if self.img_format:
                md_links = re.findall("!\\[.*?\\]\\(.*?\\)", md)
                md_links += re.findall("<img src=.*/>", md)
                for ml in md_links:
                    img_url = re.findall("!\\[.*?\\]\\((.*?)\\)", ml)
                    img_url += re.findall('<img src="(.*?)"', ml)
                    img_url = img_url[0]

                    if self.img_format == "typora":
                        zoom = re.findall(r'style="zoom:(.*)%;"', ml)
                        if zoom:
                            md = md.replace(
                                ml,
                                f'<center><img src="{img_url}"  style="width:{zoom[0]}%;" /></center>',
                            )
                    else:
                        md = md.replace(ml, self.img_format.format(img_url))

            if self.gen_network_file:
                path_net = os.path.join(
                    os.path.dirname(self.path),
                    "_network".join(os.path.splitext(os.path.basename(self.path))),
                )
                with open(path_net, "w", encoding="utf-8") as fw:
                    fw.write(md)
                    print(f"图片链接替换完成，生成新markdown:{path_net}")
            return md


class CodeToMarkDown:
    """_summary_"""

    __slots__ = [
        "path",
        "md_path",
        "code_file_path",
        "exclude_dirs",
        "exclude_files",
        "md_suffix_table",
        "include_exts",
        "key_work_filter_list",
    ]

    def __init__(self, path: str = None) -> None:
        if path:
            self.path = path
        else:
            self.path = os.getcwd()
        # 需要排除的目录
        self.exclude_dirs = [
            "__pycache__",
            "venv",
            "build",
            "dist",
            "node_modules",
            "public",
            "LICENSE",
            "assets",
            "vendor",
            "tmp",
            "static",
            "templates",
            "bin",
            "obj",
            "Migrations",
            "Properties",
            "packages",
        ]
        # 排除的文件的后缀
        self.exclude_files = [
            "_NOTE.md",
            ".d.ts",
            ".lock",
            ".png",
            ".woff2",
            ".ttf",
            ".woff",
            ".css",
            "README.md",
            ".toml",
            "swagger-ui-bundle.js",
            "-lock.json",
            "zz_code2md.py",
            "zz.py",
            "temp.md",
        ]
        # 文件后缀名对应的 md code代码提示名
        self.md_suffix_table = {"command": "sh", "csproj": "xml"}
        # 需要包含的文件后缀名
        self.include_exts = [
            ".py",
            ".vue",
            ".js",
            ".ts",
            ".html",
            ".go",
            ".mod",
            ".json",
            ".txt",
            ".sh",
            ".command",
            ".cs",
            ".jsx",
            ".sh",
            ".bat",
            ".xaml",
            ".csproj",
            ".http"
        ]
        # 需要过滤的文件名的后缀
        self.key_work_filter_list = [""]

    def generate_md(self):
        self.__generate_md_file_path()
        self.__collect_code_files()
        self.__generate_md_file()

    def __generate_md_file_path(self):
        cur_time_str = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
        md_name = f"Z_{cur_time_str}_NOTE.md"
        self.md_path = os.path.join(self.path, md_name)

    def __collect_code_files(self):
        """_summary_
        Returns:
            _type_: _description_
        """
        self.code_file_path = []
        for root, dirs, files in os.walk(self.path):
            # 过滤不符合的文件夹------------------------------------------------------------------------
            dirs[:] = [
                d
                for d in dirs
                if not d.startswith(".")
                and not any(ex in d for ex in self.exclude_dirs)
            ]
            # 过滤不符合的文件-----------------------------------------------------------------------------
            files[:] = [
                f
                for f in files
                if not f.startswith(".")
                and not any(ex in f for ex in self.exclude_files)
            ]
            # 筛选所有符合后缀的文件------------------------------------------------------------------------
            for file in files:
                # 正向过滤含有(\.py|vue|js|ts)$ 结尾的文件
                if any(file.endswith(ext) for ext in self.include_exts):
                    self.code_file_path.append(os.path.join(root, file))

    def __generate_md_file(self):
        for i, code_file_path in enumerate(self.code_file_path):
            print(i + 1, "->", self.__get_md_title_level_one(code_file_path))
            self.__readcode_writemd(code_file_path)

    def __get_md_title_level_one(self, code_file_path):
        """获取每个代码文件的md标题,去掉项目之前的文件路径
        Args:
            code_file_path (_type_): 代码路径
            project_path (_type_): 项目根路径
        Returns:
            _type_: 每个代码文件的md标题
        """
        # Get the common prefix of the two paths
        common_prefix = os.path.commonprefix([code_file_path, self.path])
        # Get the different parts of the two paths
        diff1 = code_file_path[len(common_prefix) + 1 :]
        md_title = os.path.join(os.path.basename(self.path), diff1)
        return md_title

    def __readcode_writemd(self, code_file_path):
        """_summary_
        Args:
            code_file_path (_type_): _description_
        """
        with open(code_file_path, "r", encoding="utf-8") as f:  # 打开文件
            try:
                content = f.read()
            except Exception as e:
                print(f"{code_file_path}{e}文件编码读取错误")
                content = ""
            self.__write2md(content, code_file_path)

    def __write2md(
        self,
        content,
        code_file_path,
    ):
        """_summary_
        Args:
            content (_type_): _description_
            suffix (_type_): _description_
            code_file_path (_type_): _description_
        """
        with open(self.md_path, "a", encoding="utf-8") as f:  # 打开文件
            md_title_level_one = self.__get_md_title_level_one(code_file_path)
            code_label = self.__get_code_md_lable_by_suffix(code_file_path)
            f.write("\n")
            f.write(f"# `{md_title_level_one}`\n\n")
            f.write(f"```{code_label}\n")
            f.write(content)
            f.write("\n")
            f.write("```\n\n\n")

    def __get_code_md_lable_by_suffix(self, code_file_path):
        suffix = re.findall(r'\.[^.\\/:*?"<>|\r\n]+$', code_file_path)
        if len(suffix):
            suffix = suffix[0][1:]
        if self.md_suffix_table.get(suffix) is not None:
            return self.md_suffix_table.get(suffix)
        return suffix


class MarkdownToCode:
    """_summary_
    Returns:
        _type_: _description_
    """

    __slots__ = ["path", "base_dir"]

    def __init__(self, path: str = None) -> None:
        if path:
            self.path = path
        else:
            self.path = self.__get_latest_md_file_path()

    def __get_latest_md_file_path(self):
        dst_md_files = []
        for root, _, files in os.walk(os.getcwd()):
            for file in files:
                if file.endswith("_NOTE.md"):
                    dst_md_files.append(os.path.join(root, file))

        return sorted(dst_md_files).pop()

    def generate_code(self):
        self.__set_base_dir()
        self.__read_md_file()

    def __read_md_file(self):
        """_summary_"""
        with open(self.path, "r", encoding="utf-8") as f:  # 打开文件
            md_text = f.read()
        # Match the first-level headings and code blocks
        # \n{1,}# `(.+)`\n{1,}```\w{2,5}\n{1,}
        pattern = r"^# `(.+)`\n{1,}```(?:\w{2,}\n)([\s\S]+?)\n{1,}```\n{1,}"
        matches = re.findall(pattern, md_text, re.MULTILINE)
        # Loop over the matches
        for i, (file_path, code) in enumerate(matches):
            print(f"{i}->", file_path)
            self.__create_from_file_path(file_path, code)

    def __set_base_dir(self):
        self.base_dir = os.path.dirname(self.path)

    def __create_from_file_path(self, file_path, content):
        """_summary_
        Args:
            file_path (_type_): _description_
            content (_type_): _description_
        """
        dir_path = os.path.join(self.base_dir, os.path.dirname(file_path))
        os.makedirs(dir_path, exist_ok=True)
        full_file_path = os.path.join(self.base_dir, file_path)
        with open(full_file_path, "w", encoding="utf-8") as f:
            f.write(content)


class CollectMarkdownNote:
    """_summary_"""

    __slots__ = [
        "path",
        "md_path",
        "cur_file_name",
        "cur_file_new_name",
        "md_file_paths",
        "dotnet_md_files",
        "python_md_files",
        "dotnet_line_number_start",
        "dotnet_split_flag",
        "dotnet_file_names",
        "python_split_flag",
        "current_new_md_file_name",
        "save_md_file_heads",
        "split_flag",
        "other_split_flag",
        "other_md_files",
        "latest_code_txt",
        "dst_folder",
        "md_file_names",
    ]

    def __init__(self, path: str = None) -> None:
        if path:
            self.path = path
        else:
            self.path = os.getcwd()

        self.dotnet_line_number_start = []

        self.dotnet_file_names = []
        self.current_new_md_file_name = None

        # 需要保留的markdown文件的开头
        # self.save_md_file_heads = ["zz_dotnet", "zz_python", "zz_csharp", "zz_note", "zz_"]
        self.save_md_file_heads = ["zz_"]
        # 需要需要的markdown文件,zz_开头,不在zz_note里面的markdown文件
        self.md_file_paths = []
        self.md_file_names = []
        #  需要收集的关于dotent的md文件,zz_开头,不在zz_note里面
        self.dotnet_md_files = []
        #  需要收集的关于python的md文件,zz_开头,不在zz_note里面
        self.python_md_files = []
        #  需要收集的关于python的md文件,zz_开头,不在zz_note里面
        self.other_md_files = []
        # 即将生成的python文件的文件名,就是当前文件的文件夹,加上时间戳的后缀
        self.cur_file_new_name = None
        # 当前这个python脚本的文件名
        self.cur_file_name = os.path.basename(__file__)

    def collect_markdown(self):
        """收集当前项目中的markdown笔记"""
        self.__get_cur_markdown_notes()
        self.__get_dst_folder()
        # self.__read_cur_markdown_notes()
        # self.__get_latest_txt_file()
        # self.__generate_new_python_file()
        self.__copy_md_file_to_dst()

    def __copy_md_file_to_dst(self):
        # print("\n")
        # class_tags = set()
        class_tag = "other"
        for i, md_file in enumerate(self.md_file_paths):
            # print(md_file)
            # print(self.md_file_names[i])
            res = re.findall(re.compile(r"^zz_(.[^_]{1,}).*"), self.md_file_names[i])
            if len(res) > 0:
                class_tag = res[0]
            # res = re.findall(
            #     re.compile(r"^zz_(.[^_]{1,})_(.[^_]{1,})_"), self.md_file_names[i]
            # )
            # if len(res) > 0:
            #     class_tags.add(res[0][1])
            # class_tags_list = list(class_tags)
            md_dst_folder = os.path.join(self.dst_folder, class_tag)
            # print(md_dst_folder)
            if not os.path.exists(md_dst_folder):
                os.makedirs(md_dst_folder, exist_ok=True)
            # print(self.md_file_names[i])
            # print(self.__get_time_suffix(md_file))
            new_md_file_name = (
                os.path.splitext(self.md_file_names[i])[0]
                + self.__get_time_suffix(md_file)
                + ".md"
            )
            # print(new_md_file_name)
            # print(os.path.join(md_dst_folder,new_md_file_name))
            new_md_file_path = os.path.join(md_dst_folder, new_md_file_name)
            # print(new_md_file_path)
            # print(os.path.exists(new_md_file_path))
            if os.path.exists(new_md_file_path):
                print(f"{i} -> 跳过, 已经存在, {md_file}")
                continue

            print(f"{i} -> 复制, {md_file}")
            shutil.copyfile(md_file, new_md_file_path)

    def __write2md(self, line):
        # 如我文件名不为空,代表可以写入,同时要过滤到python中的注释符号,防止python脚本出现错误
        if (
            (self.current_new_md_file_name is not None)
            and line != '"""\n'
            and line != '"""'
            and line != '\n"""'
        ):
            nf = open(self.current_new_md_file_name, "a+", encoding="utf-8")
            nf.write(line)
            nf.close()

    def un_collect_markdown(self):
        self.__get_dst_folder()
        shutil.copytree(self.dst_folder, os.path.join(self.path, "zz_note"))

    def __get_zz_code_file(self):
        # 获取当前目录的路径
        current_dir = os.getcwd()
        # 获取当前目录下的所有文件名
        file_list = os.listdir(current_dir)
        # 筛选出以zz_开头且以.txt结尾的文件名
        txt_files = [f for f in file_list if f.startswith("zz_") and f.endswith(".txt")]
        if len(txt_files) > 0:
            print(txt_files[0])
            return txt_files[0]

    def __get_output_md_file_name_by_line(self, line):
        # 输出zz_note的子文件夹的名称,从"""==python==提取
        dir_name = "other"
        name = "other"
        pattern = re.compile(r"^\"\"\"#==(.[^_]{1,})_.*==(.+).md")
        res = pattern.match(line)
        if res:
            dir_name = res.groups()[0]
            name = res.groups()[1]

        # 生成的markdown文件的文件夹,zz_note/python,或者给zz_dotnet,取决于什么类型的文件
        dir_path = os.path.join("zz_note", dir_name)
        os.makedirs(dir_path, exist_ok=True)

        return "zz_note/" + dir_name + "/" + name + ".md"

    def __read_cur_markdown_notes(self):
        """_summary_"""

        for md_file in self.md_file_paths:
            if "dotnet" in md_file:
                self.dotnet_md_files.append(md_file)
            elif "python" in md_file:
                self.python_md_files.append(md_file)
            elif "other" in md_file:
                self.other_md_files.append(md_file)

    def __get_cur_markdown_notes(self):
        """_summary_"""
        print("开始收集,所以以zz_开头的,不在zz_note文件夹中的markdown文件")
        pattern = re.compile(r"zz_(\w+)_")

        for root, dirs, files in os.walk(self.path):
            dirs[:] = [d for d in dirs if "zz_note" not in d]
            # 过滤符合的文件-----------------------------------------------------------------------------
            files[:] = [
                f
                for f in files
                if not f.startswith(".") and any(ex in f for ex in [".md"])
            ]
            # 筛选所有符合后缀的文件------------------------------------------------------------------------
            for i, file in enumerate(files):
                res = pattern.findall(file)
                if len(res) > 0:
                    print(i + 1, "->", file)
                    self.md_file_paths.append(os.path.join(root, file))
                    self.md_file_names.append(file)

    def __get_time_suffix(self, md_file_path):
        file_stats = os.stat(md_file_path)
        st_ctime = datetime.datetime.fromtimestamp(int(file_stats.st_ctime)).strftime(
            "%Y%m%d_%H%M%S"
        )
        st_mtime = datetime.datetime.fromtimestamp(int(file_stats.st_mtime)).strftime(
            "%Y%m%d_%H%M%S"
        )
        return st_ctime + "_" + st_mtime

    def __get_new_txt_file_name(self):
        cur_time_str = str(datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S"))
        file_names = self.cur_file_name.split("_")
        if len(file_names) > 1:
            self.cur_file_new_name = (
                f"{os.path.splitext(file_names[0])[0]}_{cur_time_str}.txt"
            )
        else:
            self.cur_file_new_name = (
                f"{os.path.splitext(self.cur_file_name)[0]}_{cur_time_str}.txt"
            )

    def __get_cur_file_name(self, md_file_path):
        return os.path.splitext(os.path.basename(md_file_path))[0]

    def __get_cur_file_create_and_modify_time(self, md_file_path):
        file_stats = os.stat(md_file_path)
        return (int(file_stats.st_ctime), int(file_stats.st_mtime))

    def __get_dst_folder(self):
        system = platform.system()
        if system == "Windows":
            self.dst_folder = r"D:/zz_note"
        elif system == "Darwin":
            self.dst_folder = r"/Users/song/Code/zz_note"
        else:
            print("Unknown system")

    def __get_latest_txt_file(self):
        system = platform.system()
        if system == "Windows":
            dir_path = r"D:/zz_note"
            self.latest_code_txt = os.path.join(
                dir_path, self.__get_latest_txt_by_path(dir_path)
            )
        elif system == "Darwin":
            dir_path = r"/Users/song/Code/zz_note"
            self.latest_code_txt = os.path.join(
                dir_path, self.__get_latest_txt_by_path(dir_path)
            )
        else:
            print("Unknown system")

    def __get_latest_txt_by_path(self, path):
        """
        获取指定路径下标题时间最新的 txt 文件

        Args:
            path: 指定路径

        Returns:
            最新的 txt 文件
        """
        txt_files = []
        for file in os.listdir(path):
            if file.endswith(".txt"):
                txt_files.append(file)

        sorted_txt_files = sorted(txt_files)
        if len(sorted_txt_files) > 0:
            return sorted_txt_files[-1]

    def __generate_new_python_file(self):
        """_summary_"""

        nf = open(self.cur_file_new_name, "a+", encoding="utf-8")
        f = open(self.latest_code_txt, "r", encoding="utf-8")
        for line in f:
            nf.write(line)

        nf.write("\n")
        for md_file in self.md_file_paths:
            split_flag = "other"
            pattern = re.compile(r"zz_(\w+)_")
            res = pattern.findall(md_file)
            if len(res) > 0:
                split_flag = res[0]

            md_title = self.__get_cur_file_name(md_file)
            content = self.__read_md_file(md_file)
            create_time, modify_time = self.__get_cur_file_create_and_modify_time(
                md_file
            )
            nf.write(
                f'\n\n"""#=={split_flag}=={md_title}_{str(create_time)}_{str(modify_time)}.md\n\n'
            )
            nf.write(self.__filter_python_comment(content))
            nf.write('\n"""\n\n')

        # f.close()
        nf.close()
        # 备份新生成的python文件
        self.__copy_current_python_file_to_dst_dir(self.cur_file_new_name)

    def __copy_current_python_file_to_dst_dir(self, current_python_file_name):
        """备份新生成的python文件,到特定的文件夹
        Args:
            current_python_file_name (_type_): _description_
        """
        system = platform.system()
        if system == "Windows":
            dir_path = r"D:/zz_note"
            os.makedirs(dir_path, exist_ok=True)
            shutil.copy(
                current_python_file_name,
                os.path.join(dir_path, current_python_file_name),
            )
        elif system == "Darwin":
            dir_path = r"/Users/song/Code/zz_note"
            os.makedirs(dir_path, exist_ok=True)
            shutil.copy(
                current_python_file_name,
                os.path.join(dir_path, current_python_file_name),
            )
        else:
            print("Unknown system")

    def __filter_python_comment(self, content: str):
        return content.replace('"""', "")

    def __read_md_file(self, file):
        with open(file, "r", encoding="utf-8") as f:
            content = f.read()
            return content


def backup_current_project():
    """_summary_"""
    src_dir = os.path.dirname(__file__)
    cur_time_str = str(datetime.datetime.now().strftime("%Y%m%d_%H%M%S"))
    compress_filename = f"{os.path.basename(src_dir)}_{cur_time_str}"
    dst_dir = os.path.join(
        os.path.dirname(os.path.dirname(__file__)),
        compress_filename,
    )
    shutil.copytree(src_dir, dst_dir)


if __name__ == "__main__":
    print("===============================start===============================")
    print("1. Project Convert to Markdown    2. Markdown Convert to Project")
    print("3. Collect Markdown Notes         4. Uncollect Markdown Notes")
    print("5. Backup the project             6. Upload a markdown file ")
    try:
        option_number = int(input("Please input a number: "))
    except Exception as e:
        option_number = 0
    print("您输入的整数是:", option_number)
    if option_number == 1:
        code2md = CodeToMarkDown()
        code2md.generate_md()
    elif option_number == 2:
        md_path = input("请输入需要转换的markdown文件路径(默认使用当前路径最新的markdown文件) : ")
        md2code = MarkdownToCode(md_path)
        md2code.generate_code()
    elif option_number == 3:
        collect_md = CollectMarkdownNote()
        collect_md.collect_markdown()
    elif option_number == 4:
        is_del = input("是否要删除现有的文件夹(Y/N): ")
        if is_del == "Y" or is_del == "y":
            try:
                res = shutil.rmtree("zz_note")
                print("zz_note文件夹,删除成功")
            except FileNotFoundError as e:
                print("no such directory,zz_note")
        collect_md = CollectMarkdownNote()
        collect_md.un_collect_markdown()
    elif option_number == 5:
        backup_current_project()
    elif option_number == 6:
        md_path = input("请输入需要上传的markdown文件路径: ")
        md2cnblog = MarkdownToCnblog(os.path.abspath(md_path))
        md2cnblog.upload_markdown()
    else:
        print("unknown option")
    print("===============================done===============================")



